﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.IO;
using System.Windows;

namespace Fire_Phone
{
    public class PublicFunction
    {
        public byte AddressBook_Address_CharNum;                 //用于限定通讯录地址的长度，最多13个字节
        public byte AddressBook_Name_CharNum;                    //用于记录通讯录文件名称的长度，最多40个字节

        public PublicFunction() {
            //将byte[]重新编码成GB2312;
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
        }

        public static Boolean New_Creat_Address_Book = false;               //全局变量，用于记录通讯录文件是否是经过新建通讯录文件打开的，若是新建文件打开则在保存时直接将改动的数据写入通讯录文件，否则保存数据的时候需要选择另存文件的地址及名称

        /*子函数，判断输入的字符是否是ASCII码或者存在于GB2312字符库*/
        public Boolean IsGB2312(string Text, Boolean IsAddressBook_Name)
        {
            Boolean GB2312 = false;
            byte[] CharCode;
            try
            {
                //获得字符的GB18030字符集的编码（此字符集向下兼容GB2312字符集）
                //CharCode = System.Text.Encoding.GetEncoding("gb18030").GetBytes(Text);                
                CharCode = System.Text.Encoding.GetEncoding("GB2312").GetBytes(Text);
                if (CharCode.Length <= 2)
                {
                    if (IsAddressBook_Name)
                    {
                        AddressBook_Name_CharNum += Convert.ToByte(CharCode.Length);                //计算记录通讯录文件名称所占字节数 
                    }
                    else
                    {
                        AddressBook_Address_CharNum += Convert.ToByte(CharCode.Length);                //计算讯录地址所占字节数 
                    }

                    //判断是否是ASCII码
                    if (CharCode.Length == 1)
                    {
                        if (CharCode[0] <= 0X7F)
                        {
                            ;//输入数据在ASCII码限定范围内
                            GB2312 = true;
                        }
                    }
                    //判断是否是GB2312字符集中的字符
                    else if (CharCode.Length == 2)
                    {
                        //判断输入的非汉字字符是否存在于GB2312，且存在于字库芯片内部
                        if ((((CharCode[0] >= 0XA1) && (CharCode[0] <= 0XA3)) || (CharCode[0] == 0XA9)) && ((CharCode[1] >= 0XA1) && (CharCode[1] <= 0XFE)))
                        {
                            if (((CharCode[0] == 0XA2) && (CharCode[1] <= 0XB0)) || ((CharCode[0] == 0XA9) && (CharCode[1] >= 0XF0)))          // GB2312第2区、第9区内有比较集中的空白，个别空白处此处不进行判断
                            {
                                GB2312 = false;
                            }
                            else
                            {
                                ;//在GB2312字符集的限定范围内                                
                                GB2312 = true;
                            }
                        }
                        //判断输入的是否是GB2312扩展字符（原GB2312中空白的第10区和第11区）
                        if (((CharCode[0] >= 0XAA) && (CharCode[0] <= 0XAB)) && ((CharCode[1] >= 0XA1) && (CharCode[1] <= 0XFE)))
                        {
                            if ((CharCode[0] == 0XAB) && (CharCode[1] >= 0XC1))           // GB2312第11区的扩展字符库中超过33的部分都为空白
                            {
                                GB2312 = false;
                            }
                            else
                            {
                                ;//在GB2312字符集的限定范围内
                                GB2312 = true;
                            }
                        }
                        //判断汉字字符是否是GB2312字符集中的字符
                        else if (((CharCode[0] >= 0XB0) && (CharCode[0] <= 0XF7)) && ((CharCode[1] >= 0XA1) && (CharCode[1] <= 0XFE)))
                        {
                            if ((CharCode[0] == 0XD7) && (CharCode[1] > 0XF9))      //GB2312字符库中第55区的89到94是空白的，需要单独拿出来进行判断
                            {
                                GB2312 = false;
                            }
                            else
                            {
                                ;//在GB2312字符集的限定范围内
                                GB2312 = true;
                            }
                        }
                    }
                }
            }
            catch
            {
                GB2312 = false;
            }
            //返回判定状态，为真则表示输入的字符在GB2312字符集中，为假则表示输入的字符不再GB2312字符集（字库芯片限定的字符集）中
            return GB2312;
        }

        /*子函数，得到字符的GB2312码  最多占用两个字符，字符数组元素不得为0，0*/
        private byte[] Get_GB2312(string Text)
        {
            byte[] CharCode = { 0, 0 };
            byte[] GB2312_Code = { 0, 0 };
            try
            {
                //获得字符的GB18030字符集的编码（此字符集向下兼容GB2312字符集）
                CharCode = System.Text.Encoding.GetEncoding("gb18030").GetBytes(Text);
                if (CharCode.Length <= 2)
                {
                    //判断是否是ASCII码
                    if (CharCode.Length == 1)
                    {
                        if (CharCode[0] <= 0X7F)
                        {
                            GB2312_Code = CharCode;
                        }
                    }
                    //判断是否是GB2312字符集中的字符
                    else if (CharCode.Length == 2)
                    {
                        //判断输入的非汉字字符是否存在于GB2312，且存在于字库芯片内部
                        if ((((CharCode[0] >= 0XA1) && (CharCode[0] <= 0XA3)) || (CharCode[0] == 0XA9)) && ((CharCode[1] >= 0XA1) && (CharCode[1] <= 0XFE)))
                        {
                            if (!(((CharCode[0] == 0XA2) && (CharCode[1] <= 0XB0)) || ((CharCode[0] == 0XA9) && (CharCode[1] >= 0XF0))))          // GB2312第2区、第9区内有比较集中的空白，个别空白处此处不进行判断
                            {
                                ;//在GB2312字符集的限定范围内                                
                                GB2312_Code = CharCode;
                            }
                        }
                        //判断输入的是否是GB2312扩展字符（原GB2312中空白的第10区和第11区）
                        if (((CharCode[0] >= 0XAA) && (CharCode[0] <= 0XAB)) && ((CharCode[1] >= 0XA1) && (CharCode[1] <= 0XFE)))
                        {
                            if (!((CharCode[0] == 0XAB) && (CharCode[1] >= 0XC1)))           // GB2312第11区的扩展字符库中超过33的部分都为空白
                            {
                                ;//在GB2312字符集的限定范围内
                                GB2312_Code = CharCode;
                            }
                        }
                        //判断汉字字符是否是GB2312字符集中的字符
                        else if (((CharCode[0] >= 0XB0) && (CharCode[0] <= 0XF7)) && ((CharCode[1] >= 0XA1) && (CharCode[1] <= 0XFE)))
                        {
                            if (!((CharCode[0] == 0XD7) && (CharCode[1] > 0XF9)))      //GB2312字符库中第55区的89到94是空白的，需要单独拿出来进行判断                          
                            {
                                ;//在GB2312字符集的限定范围内
                                GB2312_Code = CharCode;
                            }
                        }
                    }
                }
            }
            catch
            {
                return CharCode;
            }

            return GB2312_Code;
        }

        /*子函数，将需要更新的信息更新到指定的文档文件中*/
        public Boolean UpDate_Config_Information(string Path, string User_Name, string Config_Num)
        {
            Boolean IsOkey = false;         //定义标记  判断是否完成更新

            /*配置文件的更新*/
            if (Path.Contains(".yzc"))
            {
                byte  Second_Row_Bytes_Num = 0;             //定义第二行数字的个数
                /*获得配置文件中的第一行的首字符与第二行的字符*/
                ArrayList  Config_Random = Random_First_Char(Convert.ToByte(Config_Num.Substring(0, Config_Num.Length - 1)));
                //如果获得了第一行的首字符与其对应的第二行数字代码，则继续进行配置文件的更新

                byte[] array = System.Text.Encoding.ASCII.GetBytes(Convert.ToString(Config_Random[0])); 
                byte  asciicode = (byte)(array[0]);

                if ((asciicode >= 65) && (asciicode < 91))
                {
                    ArrayList CharCode_Row_1 = new ArrayList();
                    //获得配置文件第一行首字符的ASCII码的地址(经过取反加1)
                    ArrayList a = Address_In_Chip(Convert.ToString(Config_Random[0]));
                    for (byte index = 0; index < a.Count; index++)
                    {
                        CharCode_Row_1.Add(a[index]);
                    }                    
                    //获得用户名的GB2312码对应的地址（经取反加1）
                    for (byte index = 0; index < User_Name.Length; index++)
                    {
                        ArrayList b = Address_In_Chip(User_Name.Substring(index, 1));
                        for (byte index_1 = 0; index_1 < b.Count; index_1++)
                        {
                            CharCode_Row_1.Add(b[index_1]);                           
                        }                      
                    }
                    //将第二行数据添加到动态数组中                    
                    ArrayList c = new ArrayList();
                    for (byte index = 1;index < Config_Random.Count;index ++)
                    {
                        ArrayList d = Address_In_Chip(Convert.ToString(Config_Random[index]));
                        for (byte index_2 = 0; index_2 < d.Count; index_2++)
                        {
                            c.Add(d[index_2]);
                        }
                        d = null;
                    }

                    for (byte index_1 = 0; index_1 < c.Count; index_1++)
                    {
                        CharCode_Row_1.Add(c[index_1]);
                        if (index_1 == c.Count - 1)
                        {
                            Second_Row_Bytes_Num = Convert.ToByte (c.Count);
                        }
                    }                    
                    //将获得到配置文件信息添加到配置文件中
                    StreamWriter sw1 = new StreamWriter(Path,false,Encoding.Default);
                    for (Int32  index = 0; index < CharCode_Row_1.Count - Second_Row_Bytes_Num; index++)
                    {
                        string Char = Convert.ToString(Convert.ToByte(CharCode_Row_1[index]), 2).ToUpper();
                        //判断是否需要在单个2进制的代码前添加0
                        if (Char.Length != 8)
                        {
                            for (byte i = (byte)Char.Length; i < 8; i++)
                            {
                                Char = "0" + Char;
                            }
                        }
                        sw1.Write(Char);//开始写入配置文件的第一行
                        if (index != CharCode_Row_1.Count - Second_Row_Bytes_Num)
                        {
                            sw1.Write(" ");
                        }
                    }
                    sw1.WriteLine();            //添加换行符    
                    sw1.Write("\n");
                    //填充第二行的数据
                    for (Int32  index = (CharCode_Row_1.Count - Second_Row_Bytes_Num); index < CharCode_Row_1.Count; index++)
                    {
                        string Char = Convert.ToString(Convert.ToByte(CharCode_Row_1[index]), 2).ToUpper();
                        //判断是否需要在单个2进制的代码前添加0
                        if (Char.Length != 8)
                        {
                            for (byte i = (byte)Char.Length; i < 8; i++)
                            {
                                Char = "0" + Char;
                            }
                        }
                        sw1.Write(Char);//开始写入配置文件的第一行
                        if (index != CharCode_Row_1.Count - 1)
                        {
                            sw1.Write(" ");
                        }
                    }                    
                    sw1.Flush();
                    sw1.Close();
                    MessageBox.Show("生成配置文件成功，配置文件地址： " + Path);
                }
                else
                {
                    MessageBox.Show("生成配置文件出现问题，请重新生成配置文件","错误提示");
                    IsOkey = false;
                }  
            }           
            return IsOkey;
        }

        /*依据设定的门数随机生成配置文件第一行的首字符与其对应的第二行的数字*/
        private ArrayList  Random_First_Char(byte Can_Be_Used_Num)
        {
            ArrayList Num_Code = new ArrayList();           //需要返回的动态数组
            if (Can_Be_Used_Num != 0)
            {
                //首先随机生成A~Z的第一行首字符
                Random Random_Char = new Random();
                //string Random_Char_1 = string.Empty;
                byte[] array = new byte[1]; 
                array[0] =Convert.ToByte(Random_Char.Next(65, 91));
                Num_Code.Add( System.Text.Encoding.ASCII.GetString(array));         //限定随机生成的字符范围从A~Z并将其加到动态数组中

                /*根据传递进来的门数与得到的第一行首字符进行计算应该得到的第二行数字*/
                switch (Can_Be_Used_Num)
                {
                    case 20:         //设置一共20门分机可用的情况
                        if (array[0] <= 73)
                        {
                            if (array[0] == 65)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add("0");
                            }
                            else
                            {
                                string Second_Row = Convert.ToString(5 * (array[0] - 65), 16).ToUpper();
                                if (Second_Row.Length == 1)
                                {
                                    Num_Code.Add("0");
                                    Num_Code.Add(Second_Row);
                                }
                                else if (Second_Row.Length == 2)
                                {
                                    Num_Code.Add(Second_Row.Substring(0,1));
                                    Num_Code.Add(Second_Row.Substring(1,1));
                                }                                
                            }
                        }
                        else
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 64) + 1,16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        break;
                    case 40:        //设置一共40门分机可用的情况
                        if (array[0] <= 73)
                        {                        
                            string Second_Row = Convert.ToString(5 * (array[0] - 65) + 1, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        else
                        {                          
                            string Second_Row = Convert.ToString(5 * (array[0] - 64) + 2, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        break;
                    case 60:        //设置一共60门分机可用的情况
                        if (array[0] < 73)
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 65) + 2, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        else
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 63) - 2, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        break;
                    case 80:        //设置一共80门分机可用的情况
                        if (array[0] < 73)
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 65) + 3, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        else
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 63) - 1, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        break;
                    case 99:        //设置一共99门分机可用的情况
                        if (array[0] < 73)
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 65) + 4, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        else
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 63), 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }   
                        }
                        break;
                    case 127:        //设置一共127门分机可用的情况
                        if (array[0] < 73)
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 65) + 4, 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }
                            else if (Second_Row.Length == 3)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                                Num_Code.Add(Second_Row.Substring(2, 1));
                            }
                        }
                        else
                        {
                            string Second_Row = Convert.ToString(5 * (array[0] - 63), 16).ToUpper();
                            if (Second_Row.Length == 1)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row);
                            }
                            else if (Second_Row.Length == 2)
                            {
                                Num_Code.Add("0");
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                            }
                            else if (Second_Row.Length == 3)
                            {
                                Num_Code.Add(Second_Row.Substring(0, 1));
                                Num_Code.Add(Second_Row.Substring(1, 1));
                                Num_Code.Add(Second_Row.Substring(2, 1));
                            }
                        }
                        break;                  
                    default:
                        break;
                }
            }
            return Num_Code;
        }

        /*计算出字符在字库芯片中的地址*/
        private ArrayList Address_In_Chip(string Char)
        {
            //变量，用于存放字符在字库芯片中的位置
            ArrayList Address_In_Chip_Code = new ArrayList();           
            
            if (Get_GB2312(Char).Length == 1)
            {
                byte Code_Char_1;
                Int32 Address = 0;
                Int32 Address_Encryption = 0;           //加密后的地址
                Code_Char_1 = Get_GB2312(Char)[0];
                if ((Code_Char_1 >= 0X20) && (Code_Char_1 <= 0X7E))
                {
                    Address = (Code_Char_1 - 0X20) * 16 + 0X3CF80;
                    Address_Encryption = (Int32 ) (0XFFFFFFFF - Address + 1);
                    byte[] arr = System.BitConverter.GetBytes(Address_Encryption);                               
                    for (byte index = 0; index < arr.Length; index++)
                    {
                        //Address_In_Chip_Code.Add(arr[index]);                                        //获得低位在前 高位在后的数组    加密之后 
                        Address_In_Chip_Code.Add(arr[arr.Length - 1 - index]);                  //获得高位在前 低位在后的数组   加密之后                        
                    }
                    Address_In_Chip_Code.Add((byte)0X08);     //添加的后缀表示字母或是数字
                }
                else
                {
                    ;
                }
            }
            else if (Get_GB2312(Char).Length == 2)
            {
                byte Code_Char_1;
                byte Code_Char_2;
                Int32 Address = 0;
                Int32 Address_Encryption = 0;           //加密后的地址
                Code_Char_1 = Get_GB2312(Char)[0];
                Code_Char_2 = Get_GB2312(Char)[1];
                if ((Code_Char_1 == 0XA9) && (Code_Char_2 >= 0XA1))
                {
                    Address = (282 + (Code_Char_2 - 0XA1)) * 32;
                    Address_Encryption = (Int32)(0XFFFFFFFF - Address + 1);
                }
                else if ((Code_Char_1 >= 0XA1) && (Code_Char_1 <= 0XA3) && (Code_Char_2 >= 0XA1))
                {
                    Address = ((Code_Char_1 - 0XA1) * 94 + (Code_Char_2 - 0XA1)) * 32;
                    Address_Encryption = (Int32)(0XFFFFFFFF - Address + 1);
                }
                else if ((Code_Char_1 >= 0XB0) && (Code_Char_1 <= 0XF7) && (Code_Char_2 >= 0XA1))
                {
                    Address = ((Code_Char_1 - 0XB0) * 94 + (Code_Char_2 - 0XA1) + 846) * 32;
                    Address_Encryption = (Int32)(0XFFFFFFFF - Address + 1);
                }

                byte[] arr = System.BitConverter.GetBytes(Address_Encryption);                                   
                for (byte index = 0; index < arr.Length; index++)
                {
                    //Address_In_Chip_Code.Add(arr[index]);                                        //获得低位在前 高位在后的数组  加密之后    
                    Address_In_Chip_Code.Add(arr[arr.Length - 1- index]);                  //获得高位在前 低位在后的数组  加密之后                    
                }
                Address_In_Chip_Code.Add((byte)0X0A);     //添加的后缀表示汉字
            }
            return Address_In_Chip_Code;                       
        }

    }
}
